home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / misc_src / knowhow4 / outwin.cpp < prev    next >
C/C++ Source or Header  |  1995-11-01  |  17KB  |  715 lines
  1. #include <stdlib.h>
  2. #include "outwin.h"
  3. #include "cursor.h"
  4. #include "global.h"
  5.  
  6. loc get_param(char* str)              // Read parameter for command and
  7.     {                                 // convert in to number
  8.     int sh = strchr(str, ' ') - str;  // f.e. in @FONT 1 ..,  1 is parameter
  9.     char ch[5]; memset(ch, '\0', 5);
  10.     strncpy(ch, str, sh);
  11.     return loc(atoi(ch), sh + 1);
  12.     }
  13. ///////////////////////////
  14. int ret_count(char* s)          // counts '\n' symbols in the string
  15.     {
  16.     char* c = s;
  17.     int n;
  18.     for(n = 0; c = strchr(c, '\n'); n++)
  19.     c++;
  20.     return n;
  21.     }
  22. /////////////////////////
  23. OutputWindow::OutputWindow(rect coordinates, char* vName,
  24.            int b_type, int s, int bak,
  25.            int attr, int interv, int p_height)
  26.         : Window(coordinates, "", "", s, (BORDERS)b_type)
  27.  
  28.     {
  29.     end = 0;
  30.     page = (char*)malloc(st_page_height * max_string_len);
  31.     start = loc(0, 0);
  32.     interval = interv;
  33.     bak_color = bak;
  34.     attr_color = attr;
  35.     curs = loc(0, interval);
  36.     viewName = strdup(vName);
  37.     page_height = p_height;
  38.     file_position = 0;
  39.     pages = (long*)malloc(num_pages * sizeof(long) + 2);
  40.     pages[0] = 1;
  41.     pages[1] = 0;
  42. //    contexts = (context*)malloc(MAXKEYS * sizeof(context)); // if another solutions does not work
  43. //          new context()[MAXKEYS];  // for BC 2.0
  44.     contexts = new context[MAXKEYS];      // for BC 3.0
  45.  
  46.     key_rects = new special[MAXKEYS];
  47.     number = 0;
  48.     load_file();
  49.     }
  50. ////////////////////////
  51. OutputWindow::~OutputWindow()
  52.     {
  53.     delete pages;
  54.     delete viewName;
  55.     delete page;
  56.     delete contexts;
  57.     delete key_rects;
  58.     }
  59. /////////////////////////
  60. void OutputWindow::show()
  61.     {
  62.     Window::show();
  63.     load();
  64.     view();
  65.     mouseHideCursor();
  66.     rect r = user_screen();
  67.     curs = loc(0, interval);
  68.     cursor.set_cursor(r.origin.X, r.origin.Y + interval);
  69.     cursor.show_cursor();
  70.     mouseShowCursor();
  71.     }
  72. //////////////////////////
  73. void OutputWindow::mouse_curs(loc ms_pos)
  74.     {
  75.     rect r = user_screen();
  76.     int x = ((ms_pos.X - r.origin.X) / pScreenSet->standart_width)
  77.            * pScreenSet->standart_width;
  78.     int y = ((ms_pos.Y - r.origin.Y) / interval + 1) * interval;
  79.     if(!r.contains(rect(x + r.origin.X, y + r.origin.Y - interval,
  80.     x + r.origin.X + pScreenSet->standart_width, y + r.origin.Y)))
  81.     return ;
  82.     curs = loc(x, y);
  83.     }
  84.  
  85. /////////////////////////
  86. void OutputWindow::view()
  87.     {
  88.     settextstyle(DEFAULT_FONT, HORIZ_DIR, 1);
  89.     setusercharsize(1, 1, 1, 1);
  90.     settextjustify(LEFT_TEXT, TOP_TEXT);
  91.  
  92.     rect r = user_screen();
  93.     setviewport(r.origin.X, r.origin.Y, r.corner.X, r.corner.Y, 1);
  94.  
  95.     mouseHideCursor();
  96.  
  97.     curs = loc(1, interval);
  98.  
  99.     int num = ret_count(page);
  100.     if(start.Y > num)
  101.     start.Y = num;
  102.  
  103.     char* str = page;
  104.     int count_ret = start.Y;
  105.     loc skip(0, 0);
  106.  
  107.     setfillstyle(SOLID_FILL, bak_color);
  108.     bar(0, 0, r.width(), r.height());
  109.     char tm[max_string_len];    // max len
  110.     int flag = start.X;
  111.     int is_first = 0;    // first pass - text, second - icons
  112.  
  113.     number = 0;
  114.     while(1)
  115.     {
  116.     memset(tm, '\0', max_string_len);
  117.     int i = 0;
  118.     while(str[i] != '\n' && str[i] && str[i] != '@')
  119.         {                       // @ - spec. symbol
  120.         tm[i] = str[i];
  121.         i++;
  122.         }
  123.  
  124.     if(*tm && !count_ret && strlen(tm) > flag)
  125.         {
  126.         skip.X = (skip.X - flag > 0) ? (skip.X - flag) : 0;
  127.         int real_skip = skip.X * textwidth(" ");
  128.         curs.X += real_skip;
  129.         if(!is_first)
  130.         {
  131.         bar(curs.X, curs.Y - interval + 1,
  132.             curs.X + textwidth(tm + flag + skip.X), curs.Y);
  133.         outtextat(loc(curs.X, curs.Y - interval + 1), tm + flag + skip.X);
  134.         }
  135.         curs.X += textwidth(tm + flag + skip.X);
  136.         flag = 0; skip = loc(0, 0);
  137.         }
  138.     else flag -= strlen(tm);
  139.  
  140.     if(str[i] == '\n')
  141.         {
  142.         if(curs.Y + interval <= r.height())
  143.         {
  144.         i++; curs.X = 1; flag = start.X;
  145.         if(count_ret > 0)
  146.             count_ret--;
  147.         else curs.Y += interval;
  148.         skip = loc(0, 0);         // !!!
  149.         }
  150.         else
  151.         {
  152.         if(is_first)
  153.              break;
  154.         else
  155.             {
  156.             is_first = 1;
  157.             curs = loc(1, interval);
  158.             str = page;
  159.             count_ret = start.Y;
  160.             skip = loc(0, 0);
  161.             flag = start.X;
  162.             continue;
  163.             }
  164.         }
  165.        }
  166.     switch(str[i])
  167.         {
  168.         case '@':
  169.         char command[10];
  170.         memset(command, '\0', 10);
  171.         i++;
  172.         char* c = strchr(str + i, ' ');
  173.         int n = c - str - i;
  174.         strncpy(command, str + i, n);
  175.         i += n + 1;
  176.         int fl = screenXL(flag);
  177.         skip = process(str + i, command, fl, count_ret, is_first);
  178.         i += skip.Y;
  179.         break;
  180.         }
  181.  
  182.     if(!str[i] || (curs.Y > r.height() + 1))
  183.         {
  184.         if(is_first)
  185.         break;
  186.         else
  187.         {
  188.         is_first = 1;
  189.         curs = loc(1, interval);
  190.         str = page;
  191.         count_ret = start.Y;
  192.         skip = loc(0, 0);
  193.         flag = start.X;
  194.         continue;
  195.         }
  196.         }
  197.     str = str + i;
  198.     }
  199.     setviewport(0, 0, getmaxx(), getmaxy(), 1);
  200.     mouseShowCursor();
  201.     }
  202. ////////////////////////////
  203. void OutputWindow::exe(int act)
  204.     {
  205.     e.what = act ? KEYEVENT : NOEVENT;
  206.     global_i[0] = action_type;
  207.     switch(act)
  208.     {
  209.     case AC_LEFT:  e.key = EVENT_LEFT; break;
  210.     case AC_RIGHT: e.key = EVENT_RIGHT; break;
  211.     case AC_UP:  e.key = EVENT_UP; break;
  212.     case AC_DOWN:  e.key = EVENT_DN; break;
  213.     case AC_PG_UP: e.key = EVENT_PG_UP; break;
  214.     case AC_PG_DN: e.key = EVENT_PG_DN; break;
  215.     case AC_HOME: e.key = EVENT_HOME; break;
  216.     case AC_END: e.key = EVENT_END; break;
  217.     case AC_CANCEL: e.key = (isRet(RET_REMOVE))
  218.         ? EVENT_ALT_F3 : EVENT_ESC;
  219.         break;
  220.     case AC_OK:  e.key = EVENT_F2; break;
  221.     case AC_PREV: e.key = EVENT_ALT_F1; break;
  222.     }
  223.     rect r = user_screen();
  224.     mouseHideCursor();
  225.     if(!act)
  226.     hilite();
  227.     mouseShowCursor();
  228.     while(1)
  229.     {
  230.         mouseShowCursor();
  231.     if(!act)
  232.         get_event();
  233.         mouseHideCursor();
  234.     if(e.what == KEYEVENT)
  235.         switch(e.key)
  236.         {
  237.         case EVENT_ALT_F1: box_move(AC_PREV); break;
  238.         case EVENT_RIGHT: box_move(AC_RIGHT);   break;
  239.         case EVENT_LEFT: box_move(AC_LEFT);    break;
  240.         case EVENT_UP: box_move(AC_UP); break;
  241.         case EVENT_DN: box_move(AC_DOWN); break;
  242.         case EVENT_HOME: box_move(AC_HOME); break;
  243.         case EVENT_PG_UP: box_move(AC_PG_UP); break;
  244.         case EVENT_END: box_move(AC_END); break;
  245.         case EVENT_PG_DN: box_move(AC_PG_DN); break;
  246.         case EVENT_CTRL_PG_UP: box_move(AC_CTRL_PG_UP); break;
  247.  
  248.         case EVENT_ESC: global_num = 0; unhilite();
  249.             return;
  250.         case EVENT_F6:
  251.         case EVENT_F10:
  252.         case EVENT_TAB:
  253.         case EVENT_ALT_F3:
  254.         case EVENT_ALT_F4:
  255.         case EVENT_ALT_TAB:
  256.         unhilite(); global_num = 0; return;
  257.         case EVENT_F2:
  258.         case EVENT_RETURN :
  259.             if(!act)
  260.                 {
  261.             box_move(AC_SELECT);
  262.             break;
  263.                         }
  264.                     else
  265.                         {
  266.             global_i[0] = action_type;
  267.                         global_num = 1;
  268.                         return;
  269.                         }
  270.                     case EVENT_ALT_P:
  271. //                    case EVENT_ALT_F:
  272.             global_i[0] = action_type;
  273.                         global_num = 1;
  274.                         return;
  275.         }
  276.     else
  277.         {
  278.         mouseHideCursor();
  279.         if(!mouse_in(loc(e.where())))    // outside of menu box
  280.         {
  281.         unhilite();
  282.         global_num = 0;
  283.         return;
  284.         }
  285.  
  286.         cursor.hide_cursor();
  287.         mouse_curs(loc(e.where()));
  288.         cursor.set_cursor(r.origin.X + curs.X, r.origin.Y + curs.Y);
  289.         cursor.show_cursor();
  290.         mouseShowCursor();
  291.  
  292.         box_move(AC_SELECT);
  293.         }
  294.     if(act)
  295.         return;
  296.     }
  297.     }
  298. ///////////////////////////
  299. loc OutputWindow::process(char* str, char* command, int flag, int count_ret,
  300.               int is_first)
  301.     {
  302.     rect r = user_screen();
  303.  
  304.     if(!strcmp(command, "COLOR"))
  305.     {
  306.     int n = strchr(str, ' ') - str;
  307.     char ch[5]; memset(ch, '\0', 5); strncpy(ch, str, n);
  308.     int bak_new = atoi(ch);
  309.     int m = strchr(str + n + 1, ' ') - str;
  310.     memset(ch, '\0', 5); strncpy(ch, str + n + 1, m);
  311.     int attr_new = atoi(ch);
  312.     if(is_first)
  313.         return loc(0, n + m);
  314.     setfillstyle(SOLID_FILL, bak_new);
  315.     setcolor(attr_new);
  316.     return loc(0, n + m);
  317.     }
  318.     if(!strcmp(command, "RESET_COL"))
  319.     {
  320.     if(is_first)
  321.         return loc(0, 0);
  322.  
  323.     setfillstyle(SOLID_FILL, bak_color);
  324.     setcolor(attr_color);
  325.     return loc(0, 0);
  326.     }
  327.     if(!strcmp(command, "FONT"))
  328.     {
  329.     int n = strchr(str, ' ') - str;
  330.     char ch[5]; memset(ch, '\0', 5); strncpy(ch, str, n);
  331.     int font_new = atoi(ch);
  332.     int m = strchr(str + n + 1, ' ') - str;
  333.     memset(ch, '\0', 5); strncpy(ch, str + n + 1, m);
  334.     int size_new = atoi(ch);
  335.     if(is_first)
  336.         return loc(0, n + m);
  337.  
  338.     settextstyle(font_new, HORIZ_DIR, size_new);
  339.     return loc(0, n + m);
  340.     }
  341.     if(!strcmp(command, "KEY"))
  342.     {
  343.     char ch[10];
  344.     loc w = get_param(str);
  345.     loc h = get_param(str + w.Y);
  346.  
  347.     int m = 8;
  348.     memset(ch, '\0', 10); strncpy(ch, str + w.Y + h.Y + 1, m);
  349.  
  350.     if(is_first || count_ret)
  351.         return loc(0, w.Y + h.Y + m + 2);
  352.  
  353.     key_add(loc(w.X, h.X), ch);
  354.  
  355.     return loc(0, w.Y + h.Y + m + 2);
  356.     }
  357.     if(!strcmp(command, "REVERSE"))
  358.     {
  359.     if(is_first)
  360.         return loc(0, 0);
  361.  
  362.     int attr, bak;
  363.     attr = getcolor();
  364.     struct fillsettingstype fillinfo;
  365.     getfillsettings(&fillinfo);
  366.     bak = fillinfo.color;
  367.     setcolor(bak); setfillstyle(SOLID_FILL, attr);
  368.     return loc(0, 0);
  369.     }
  370.     if(!strcmp(command, "ICON"))  // @ICON TYPE NUM
  371.     {
  372.     int n = strchr(str, ' ') - str;
  373.     char ch[5]; memset(ch, '\0', 5); strncpy(ch, str, n);
  374.     int icon_type = atoi(ch);
  375.     int m = strchr(str + n + 1, ' ') - str;
  376.     memset(ch, '\0', 5); strncpy(ch, str + n + 1, m);
  377.     int icon_num = atoi(ch);
  378.     if(!is_first)
  379.         return loc(0, n + m);
  380.     loc lt = loc(r.origin.X + curs.X - flag,
  381.              r.origin.Y + curs.Y - interval - count_ret * interval);
  382.     loc size = icon_size(icon_type);
  383.  
  384.     Icon* icon = new Icon(textLoc(lt), icon_num, icon_type,
  385.                               NO_BORDER);
  386.     imageP im = (imageP)icon->extract();
  387.     rect dest = rect(lt, lt + size - 1);
  388.     put_image_correct(im, dest);
  389.     delete im;
  390.     delete icon;
  391.  
  392.     return loc(0, n + m);
  393.     }
  394.     if(!strcmp(command, "SKIP"))     // spaces to skip
  395.     {
  396.     int n = strchr(str, ' ') - str;
  397.     char ch[5]; memset(ch, '\0', 5); strncpy(ch, str, n);
  398.     int skip = atoi(ch);
  399.     return loc(skip, n);
  400.     }
  401.     return loc(0, 0);    // loc.X - to skip, loc.Y - size of command argument
  402.     }
  403. /////////////////////////////
  404. void OutputWindow::box_move(int act)
  405.     {
  406.     int sz;
  407.     loc res;
  408.     mouseHideCursor();
  409.     rect r = user_screen();
  410.     cursor.set_cursor(r.origin.X + curs.X, r.origin.Y + curs.Y);
  411.     cursor.hide_cursor();
  412.  
  413.     switch(act)
  414.     {
  415.     case AC_SELECT:
  416.         int c_num = on_special();
  417.         if(c_num)   // number of context + 1
  418.         {
  419.         c_num--;
  420.         listed.add(loc(pages[0], start.Y));
  421.         pages[0] = contexts[c_num].page;
  422.         file_position = pages[pages[0]];
  423.         start.Y = contexts[c_num].line;
  424.         start.X = 0;
  425.         load();
  426.         view();
  427.         curs = loc(0, interval);
  428.         }
  429.         break;
  430.     case AC_PREV:
  431.         loc prev = listed.remove();
  432.         if(prev.X == 0)  break;  // at the top - no more prev. pages
  433.         pages[0] = prev.X;
  434.         start.Y = prev.Y;
  435.         file_position = pages[pages[0]];
  436.         load();
  437.         view();
  438.         curs = loc(0, interval);
  439.         break;
  440.     case AC_LEFT:
  441.         sz = pScreenSet->standart_width;
  442.         if(curs.X >= sz)      {    curs.X -= sz;        }
  443.         else if(start.X > 0)
  444.         {
  445.         res = curs;
  446.         start.X -= 1;
  447.         view();
  448.         curs = res;
  449.         }
  450.         break;
  451.     case AC_RIGHT:
  452.         sz = pScreenSet->standart_width;
  453.         if(curs.X < r.width() - interval)   { curs.X += sz;    }
  454.         else
  455.         {
  456.         res = curs;
  457.         start.X += 1;
  458.         view();
  459.         curs = res;
  460.         }
  461.         break;
  462.     case AC_HOME:
  463.         res.Y = curs.Y; start.X = 0; view(); curs = loc(0, res.Y); break;
  464.     case AC_END:
  465.         sz = r.width() / pScreenSet->standart_width;
  466.         start.X += sz;
  467.         res.Y = curs.Y;
  468.         view();
  469.         curs = loc(0, res.Y);
  470.         break;
  471.  
  472.     case AC_UP:
  473.         sz = interval;
  474.         if(curs.Y > sz)
  475.         {
  476.         curs.Y -= sz;
  477.         break;
  478.         }
  479.         if(start.Y > 0)
  480.         {
  481.         res = curs; start.Y -= 1;
  482.         view(); curs = res;
  483.         }
  484.         else                             // if we must reload
  485.         {
  486.         if(pages[0] <= 1)
  487.             break;
  488.         start.Y = page_height / 2;
  489.         pages[0]--;
  490.         file_position = pages[pages[0]];
  491.         load();
  492.         res = curs;
  493.         view();
  494.         curs = res;
  495.         }
  496.         break;
  497.     case AC_PG_UP:
  498.         if(start.Y < r.height() / interval)
  499.         {
  500.         if(pages[0] <= 1)
  501.             {
  502.             if(start.Y > 0)
  503.             {
  504.             start.Y = 0;
  505.             view();
  506.             curs = loc(0, interval);
  507.             }
  508.             break;
  509.             }
  510.         start.Y += page_height / 2 - r.height() / interval;
  511.         pages[0]--;
  512.         file_position = pages[pages[0]];
  513.         load();
  514.         }
  515.         else start.Y -= r.height() / interval;
  516.         res = curs;
  517.         view(); curs = res;  break;
  518.  
  519.     case AC_DOWN:
  520.         sz = interval;
  521.         if(curs.Y < r.height() - interval)
  522.         {
  523.         curs.Y += sz;
  524.         break;
  525.         }
  526.         if(start.Y + r.height() / interval < page_height - 1)
  527.         {
  528.         res = curs; start.Y += 1;
  529.         view(); curs = res;
  530.         }
  531.         else
  532.         {
  533.         if(end) break;
  534.         pages[0]++;
  535.         file_position = pages[pages[0]];
  536.         start.Y = page_height / 2 - r.height() / interval - 1;
  537.         load(); res = curs;
  538.         view(); curs = res;
  539.         }
  540.         break;
  541.     case AC_PG_DN:
  542.         sz = r.height() / interval;
  543.         if(start.Y + 2 * sz >= page_height)
  544.         {
  545.         if(end) break;
  546.         start.Y -= (page_height / 2 - sz);
  547.         pages[0]++;
  548.         file_position = pages[pages[0]];
  549.         load();
  550.         }
  551.         else start.Y += sz;
  552.         res = curs; view(); curs = res;
  553.         break;
  554.     case AC_CTRL_PG_UP:
  555.         pages[0] = 1;
  556.         file_position = pages[pages[0]];
  557.         start = loc(0, 0);
  558.         load(); view();
  559.         curs = loc(0, interval);
  560.         break;
  561.     }
  562.     cursor.set_cursor(r.origin.X + curs.X, r.origin.Y + curs.Y);
  563.     cursor.show_cursor();
  564.     mouseShowCursor();
  565.     }
  566. //////////////////////////
  567. int OutputWindow::load()
  568.     {
  569.     memset(page, '\0', st_page_height * max_string_len);
  570.     char str[max_string_len];
  571.     FILE *fileptr;
  572.     fileptr = fopen(viewName, "r");
  573.     fseek(fileptr, pages[pages[0]], 0);
  574.     fpos_t pos;
  575.     end = 0;
  576.     int half_count = 0;
  577.     for(int i = 0; i < page_height; i++)
  578.     {
  579.     char* c;
  580.     c = fgets(str, max_string_len - 1, fileptr);
  581.     if(c[0] == '<') //context
  582.         continue;
  583.     if(!c)
  584.         {
  585.         end = 1;
  586.         break;
  587.         }
  588.  
  589.     strcpy(page + strlen(page), str);
  590.     if(half_count == 0 && i >= page_height / 2)
  591.         {
  592.         fgetpos(fileptr, &pos);
  593.         pages[pages[0] + 1] = pos; // beginning of the next half of page
  594.         half_count = 1;
  595.         }
  596.     }
  597.  
  598.     fgetpos(fileptr, &pos);
  599.     file_position = pos;
  600.     pages[pages[0] + 2] = pos;         // end of page
  601.  
  602.     fclose(fileptr);
  603.     return end;
  604.     }
  605. //////////////////////////
  606. void OutputWindow::load_file()
  607.     {
  608.     rect r = user_screen();
  609.     FILE *fileptr;
  610.     fileptr = fopen(viewName, "r");
  611.     fpos_t pos;
  612.     int hp = 0; int lines = 0; int page_num = 1;
  613.     char str[max_string_len];    char* c;
  614.     int max = MAXKEYS;
  615.     while(1)
  616.     {
  617.     memset(str, '\0', 10);
  618.     c = fgets(str, max_string_len - 1, fileptr);
  619.     lines++;
  620.     if(lines >= page_height / 2)
  621.         {
  622.         lines = 0;
  623.         fgetpos(fileptr, &pos);
  624.         pages[page_num + 1] = pos; // beginning of the next half of page
  625.         page_num++;
  626.         }
  627.     if(!c)
  628.          break;
  629.     if (hp == max - 1)
  630.         {
  631.         contexts = (context*)realloc(contexts, MAXKEYS * sizeof(context));
  632.         max = 0;
  633.         }
  634.     if (str[0] != '<')
  635.         continue;
  636.  
  637.     strncpy(contexts[hp].cont_name, str + 1, 8);
  638.     contexts[hp].cont_name[8] = '\0';
  639.     contexts[hp].page = page_num;
  640.     if(lines < page_height - r.height() / interval)
  641.         contexts[hp].line = lines - 1;
  642.     else
  643.         contexts[hp].line = page_height - r.height() / interval;
  644.     hp++;
  645.     }
  646.  
  647.     fclose(fileptr);
  648.     }
  649. /////////////////////////////
  650. void OutputWindow::key_add(loc wh, char* ch)
  651.     {
  652.     if(number > MAXKEYS - 1)
  653.     key_rects = (special*)realloc(key_rects, MAXKEYS * sizeof(special));
  654.  
  655.     key_rects[number].ltrb = rect(curs.X, curs.Y - interval,
  656.     curs.X + wh.X * pScreenSet->standart_width,
  657.          curs.Y - interval + wh.Y * interval);
  658.  
  659.     strncpy(key_rects[number].cont_name, ch, 8);
  660.  
  661.     key_rects[number].cont_name[8] = '\0';
  662.  
  663.     number++;
  664.     }
  665.  
  666. /////////////////////////////
  667. int OutputWindow::on_special()   // number of context
  668.     {
  669.     int n = 0;
  670.     while(!key_rects[n].ltrb.contains(curs) && n < number)
  671.     n++;
  672.     if(n == number) return 0;
  673.  
  674.     int m = 0;
  675.     while(strcmp(key_rects[n].cont_name, contexts[m].cont_name))
  676.     {
  677.     if(contexts[m].cont_name[0] == '\0')
  678.         return 0;
  679.     m++;
  680.     }
  681.     return m + 1;
  682.     }
  683. /////////////////////////////
  684. void OutputWindow::jmp_to(char* context)
  685.     {
  686.     rect r = user_screen();
  687.     int m = 0;
  688.     while(strcmp(context, contexts[m].cont_name))
  689.     {
  690.     if(contexts[m].cont_name[0] == '\0')
  691.         return;
  692.     m++;    // context number
  693.     }
  694.     if(m + 1)   // number of context + 1
  695.     {
  696.     pages[0] = contexts[m].page;
  697.     file_position = pages[pages[0]];
  698.     start.Y = contexts[m].line;
  699.     start.X = 0;
  700.     }
  701.     }
  702. ////////////////////////////////////
  703. void prev_stek::add(loc page_line)
  704.     {
  705.     if(used < previous_num - 1)
  706.     { used++; previous[used] = page_line; }
  707.     else
  708.     {
  709.     for(int i = 0; i < previous_num - 1; i++)
  710.         previous[i] = previous[i + 1];
  711.     used = i;
  712.     previous[used] = page_line;
  713.     }
  714.     }
  715.